<?php
namespace app\controller;

use app\BaseController;
use app\model\DictType as DictTypeModel;
use app\model\DictData as DictDataModel;
use think\facade\Validate;

class Dict extends BaseController
{
    /**
     * 获取字典类型列表
     */
    public function typeList()
    {
        // 获取请求参数
        $params = $this->request->get();
        
        // 构建查询
        $query = DictTypeModel::order('id', 'asc');
        
        // 按字典名称搜索
        if (!empty($params['dict_name'])) {
            $query = $query->searchDictNameAttr($params['dict_name']);
        }
        
        // 按字典类型搜索
        if (!empty($params['dict_type'])) {
            $query = $query->searchDictTypeAttr($params['dict_type']);
        }
        
        // 按状态搜索
        if (isset($params['status']) && $params['status'] !== '') {
            $query = $query->searchStatusAttr($params['status']);
        }
        
        // 分页
        $list = $query->paginate([
            'list_rows' => $params['pageSize'] ?? 10,
            'page' => $params['page'] ?? 1,
        ]);
        
        return $this->success('获取成功', $list);
    }
    
    /**
     * 获取字典类型详情
     * @param int $id 字典类型ID
     */
    public function typeDetail($id)
    {
        // 验证参数
        if (!$id || !is_numeric($id)) {
            return $this->error('参数错误');
        }
        
        // 查询字典类型
        $dictType = DictTypeModel::find($id);
        if (!$dictType) {
            return $this->error('字典类型不存在');
        }
        
        return $this->success('获取成功', $dictType);
    }
    
    /**
     * 添加字典类型
     */
    public function addType()
    {
        // 获取请求数据
        $data = $this->request->post();
        
        // 验证数据
        $validate = Validate::rule([
            'dict_name' => 'require|max:100',
            'dict_type' => 'require|alphaDash|unique:dict_type|max:100',
            'status'    => 'require|in:0,1',
            'remark'    => 'max:500'
        ]);
        
        if (!$validate->check($data)) {
            return $this->error('参数错误：' . $validate->getError());
        }
        
        // 创建字典类型
        try {
            $dictType = DictTypeModel::create([
                'dict_name'   => $data['dict_name'],
                'dict_type'   => $data['dict_type'],
                'status'      => $data['status'],
                'remark'      => $data['remark'] ?? ''
            ]);
            
            return $this->success('添加成功', $dictType);
            
        } catch (\Exception $e) {
            return $this->error('添加失败：' . $e->getMessage());
        }
    }
    
    /**
     * 编辑字典类型
     */
    public function editType()
    {
        // 获取请求数据
        $data = $this->request->put();
        
        // 验证数据
        $validate = Validate::rule([
            'id'        => 'require|number',
            'dict_name' => 'require|max:100',
            'dict_type' => 'require|alphaDash|max:100',
            'status'    => 'require|in:0,1',
            'remark'    => 'max:500'
        ]);
        
        if (!$validate->check($data)) {
            return $this->error('参数错误：' . $validate->getError());
        }
        
        // 查询字典类型
        $dictType = DictTypeModel::find($data['id']);
        if (!$dictType) {
            return $this->error('字典类型不存在');
        }
        
        // 如果修改了字典类型，需要检查唯一性
        if ($data['dict_type'] !== $dictType->dict_type) {
            if (DictTypeModel::checkDictTypeUnique($data['dict_type'])) {
                return $this->error('字典类型已存在');
            }
        }
        
        // 更新字典类型
        try {
            $dictType->save([
                'dict_name' => $data['dict_name'],
                'dict_type' => $data['dict_type'],
                'status'    => $data['status'],
                'remark'    => $data['remark'] ?? $dictType->remark
            ]);
            
            return $this->success('更新成功');
            
        } catch (\Exception $e) {
            return $this->error('更新失败：' . $e->getMessage());
        }
    }
    
    /**
     * 删除字典类型
     * @param int $id 字典类型ID
     */
    public function deleteType($id)
    {
        // 验证参数
        if (!$id || !is_numeric($id)) {
            return $this->error('参数错误');
        }
        
        // 查询字典类型
        $dictType = DictTypeModel::find($id);
        if (!$dictType) {
            return $this->error('字典类型不存在');
        }
        
        // 检查是否有字典数据
        $count = DictDataModel::where('dict_type', $dictType->dict_type)->count();
        if ($count > 0) {
            return $this->error('该字典类型已被使用，不能删除');
        }
        
        // 删除字典类型
        if ($dictType->delete()) {
            return $this->success('删除成功');
        } else {
            return $this->error('删除失败');
        }
    }
    
    /**
     * 获取字典数据列表
     * @param string $dictType 字典类型
     */
    public function dataList($dictType = '')
    {
        // 获取请求参数
        $params = $this->request->get();
        
        // 构建查询
        $query = DictDataModel::order('sort', 'asc');
        
        // 按字典类型搜索
        if (!empty($dictType)) {
            $query = $query->where('dict_type', $dictType);
        } elseif (!empty($params['dict_type'])) {
            $query = $query->where('dict_type', $params['dict_type']);
        }
        
        // 按字典标签搜索
        if (!empty($params['dict_label'])) {
            $query = $query->searchDictLabelAttr($params['dict_label']);
        }
        
        // 按状态搜索
        if (isset($params['status']) && $params['status'] !== '') {
            $query = $query->searchStatusAttr($params['status']);
        }
        
        // 分页
        $list = $query->paginate([
            'list_rows' => $params['pageSize'] ?? 10,
            'page' => $params['page'] ?? 1,
        ]);
        
        return $this->success('获取成功', $list);
    }
    
    /**
     * 获取字典数据详情
     * @param int $id 字典数据ID
     */
    public function dataDetail($id)
    {
        // 验证参数
        if (!$id || !is_numeric($id)) {
            return $this->error('参数错误');
        }
        
        // 查询字典数据
        $dictData = DictDataModel::find($id);
        if (!$dictData) {
            return $this->error('字典数据不存在');
        }
        
        return $this->success('获取成功', $dictData);
    }
    
    /**
     * 添加字典数据
     */
    public function addData()
    {
        // 获取请求数据
        $data = $this->request->post();
        
        // 验证数据
        $validate = Validate::rule([
            'dict_type'  => 'require|max:100',
            'dict_label' => 'require|max:100',
            'dict_value' => 'require|max:100',
            'status'     => 'require|in:0,1',
            'sort'       => 'number',
            'remark'     => 'max:500'
        ]);
        
        if (!$validate->check($data)) {
            return $this->error('参数错误：' . $validate->getError());
        }
        
        // 检查字典类型是否存在
        $dictType = DictTypeModel::where('dict_type', $data['dict_type'])->find();
        if (!$dictType) {
            return $this->error('字典类型不存在');
        }
        
        // 创建字典数据
        try {
            $dictData = DictDataModel::create([
                'dict_type'   => $data['dict_type'],
                'dict_label'  => $data['dict_label'],
                'dict_value'  => $data['dict_value'],
                'css_class'   => $data['css_class'] ?? '',
                'list_class'  => $data['list_class'] ?? '',
                'is_default'  => $data['is_default'] ?? 0,
                'status'      => $data['status'],
                'sort'        => $data['sort'] ?? 0,
                'remark'      => $data['remark'] ?? ''
            ]);
            
            return $this->success('添加成功', $dictData);
            
        } catch (\Exception $e) {
            return $this->error('添加失败：' . $e->getMessage());
        }
    }
    
    /**
     * 编辑字典数据
     */
    public function editData()
    {
        // 获取请求数据
        $data = $this->request->put();
        
        // 验证数据
        $validate = Validate::rule([
            'id'         => 'require|number',
            'dict_type'  => 'require|max:100',
            'dict_label' => 'require|max:100',
            'dict_value' => 'require|max:100',
            'status'     => 'require|in:0,1',
            'sort'       => 'number',
            'remark'     => 'max:500'
        ]);
        
        if (!$validate->check($data)) {
            return $this->error('参数错误：' . $validate->getError());
        }
        
        // 查询字典数据
        $dictData = DictDataModel::find($data['id']);
        if (!$dictData) {
            return $this->error('字典数据不存在');
        }
        
        // 检查字典类型是否存在
        $dictType = DictTypeModel::where('dict_type', $data['dict_type'])->find();
        if (!$dictType) {
            return $this->error('字典类型不存在');
        }
        
        // 更新字典数据
        try {
            $dictData->save([
                'dict_type'   => $data['dict_type'],
                'dict_label'  => $data['dict_label'],
                'dict_value'  => $data['dict_value'],
                'css_class'   => $data['css_class'] ?? $dictData->css_class,
                'list_class'  => $data['list_class'] ?? $dictData->list_class,
                'is_default'  => $data['is_default'] ?? $dictData->is_default,
                'status'      => $data['status'],
                'sort'        => $data['sort'] ?? $dictData->sort,
                'remark'      => $data['remark'] ?? $dictData->remark
            ]);
            
            return $this->success('更新成功');
            
        } catch (\Exception $e) {
            return $this->error('更新失败：' . $e->getMessage());
        }
    }
    
    /**
     * 删除字典数据
     * @param int $id 字典数据ID
     */
    public function deleteData($id)
    {
        // 验证参数
        if (!$id || !is_numeric($id)) {
            return $this->error('参数错误');
        }
        
        // 查询字典数据
        $dictData = DictDataModel::find($id);
        if (!$dictData) {
            return $this->error('字典数据不存在');
        }
        
        // 删除字典数据
        if ($dictData->delete()) {
            return $this->success('删除成功');
        } else {
            return $this->error('删除失败');
        }
    }
    
    /**
     * 根据字典类型获取字典数据选项
     * @param string $dictType 字典类型
     */
    public function getOptions($dictType)
    {
        if (empty($dictType)) {
            return $this->error('字典类型不能为空');
        }
        
        $dictData = DictDataModel::getDictDataList($dictType);
        
        return $this->success('获取成功', $dictData);
    }
} 